{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5e0e0f3f",
   "metadata": {},
   "source": [
    "# Two-Qubit Simulator with Coupler Architecture\n",
    "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f71cb0",
   "metadata": {},
   "source": [
    "## Outline\n",
    "\n",
    "This tutorial introduces how to use Quanlse to create the two-qubit simulator with coupler architecture, analyze the $ZZ$ coupling characteristics (a common parasitic coupling in multi-qubit superconducting circuits) and demonstrate the implementation of cross resonance gates and the preparation of Bell states.The outline of this tutorial is as follows:\n",
    "+ Introduction\n",
    "+ Preparation\n",
    "+ Construct Hamiltonian\n",
    "+ Static $ZZ$ coupling analysis\n",
    "+ Cross resonance gate analysis\n",
    "+ Preparation of the Bell State\n",
    "+ Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e73da121",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "As the number of qubits in superconducting quantum chips continues to increase, quantum crosstalk between qubits will undermine the fidelity of the gate, leading to an increase in the error rate of the results. Researchers have proposed a tunable coupling architecture to implement a high-fidelity two-qubit gate \\[1\\]. This structure is composed of two qubits and a frequency-tunable coupler. As the diagram of the structure shown below, $Q_1$ and $Q_2$ are qubits, $C$ is a tunable coupler between them and $g_{1c}, g_{2c}$ are the qubit-coupler coupling strength of coupler with $Q_1$ and $Q_2$, respectively. The qubit-qubit direct coupling strength is $g_{12}$.\n",
    "\n",
    "![tunable-coupler](figures/tunable-coupler-architectrue.png)\n",
    "\n",
    "Unlike the classical direct coupling structure, the coupling between qubits can be \"turned on\" or \"turned off\" by adjusting the frequency of the coupler in the tuable coupling structure, thus reducing quantum crosstalk noise. So far tunable coupling structures have been widely used in the design of large superconducting quantum computers \\[2, 3\\].\n",
    "\n",
    "For the two-qubit with coupler architecture, Quanlse provides a wealth of analysis functions. This tutorial will demonstrate how to analyze the $ZZ$ coupling and the cross resonance gate characteristics, and perpare the bell state using this architecture."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3618117",
   "metadata": {},
   "source": [
    "## Preparation\n",
    "\n",
    "After you have successfully installed Quanlse, you could run the codes below following this tutorial. To run this tutorial, you would need to import the following packages from Quanlse and other commonly-used Python libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "730e19cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "from copy import deepcopy\n",
    "from numpy import linspace, array\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from Quanlse.Superconduct.Simulator.PulseSimQCQ import pulseSimQCQ\n",
    "from Quanlse.Superconduct.Simulator import PulseModel\n",
    "from Quanlse.Superconduct.Simulator.PulseSimQCQ import effectiveCoupling, pauliCoefficient\n",
    "from Quanlse.Utils.Functions import basis, computationalBasisList\n",
    "from Quanlse.remoteSimulator import remoteSimulatorRunHamiltonian as runHamiltonian\n",
    "from Quanlse.Utils.Plot import plotBarGraph\n",
    "from Quanlse.QOperation.FixedGate import CNOT\n",
    "from Quanlse.QOperation.RotationGate import RX"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f49ca93",
   "metadata": {},
   "source": [
    "## Construct Hamiltonian\n",
    "\n",
    "In this section, we will demonstrate how to use Quanlse to construct a physical model of the two-qubit with coupler architecture. The Hamiltonian of this architecture in the lab frame is \\[4\\]\n",
    "\n",
    "$$ \n",
    "\\hat{H}_{\\rm sys}= \\sum_{i=1,2,{\\rm C}}\\left(\\omega_{i}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i} + \\frac{\\delta_{i}}{2}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i}\\hat{a}_{i}\\right) + \\sum_{i, j=1,2,{\\rm C}}^{i \\neq j}g_{ij}(\\hat{a}_{i} + \\hat{a}_{i}^{\\dagger})(\\hat{a}_{j} + \\hat{a}_{j}^{\\dagger}),\n",
    "$$\n",
    "\n",
    "where the subscripts $1,2,{\\rm C}$ represent the two qubits and the coupler, respectively. $\\hat{a}_{i}$ and $\\hat{a}_{i}^{\\dagger}$ are the annihilation and creation operators of the corresponding components (qubits and the coupler); $\\omega_{i},\\delta_{i}$ represent the frequencies and the magnitudes of the anharmonicity of each component; $g_ {ij}$ represents the coupling strength between different elements.\n",
    "\n",
    "We use Quanlse to construct the Hamiltonian of the two-qubit with coupler achitecture for the analysis of the $ZZ$ coupling characteristics and implementation of cross resonance gates. We first define the parameters needed by the simulator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84eb79bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters setting\n",
    "couplerLevel = 3\n",
    "qubitLevel = 4\n",
    "\n",
    "subSysNum = 3\n",
    "subSysLevel = [couplerLevel, qubitLevel, qubitLevel]  # [Coupler, Control Qubit, Target Qubit]\n",
    "\n",
    "freqDict = {\n",
    "    0: 6.3 * (2 * pi),  # Coupler frequency (GHz)\n",
    "    1: 5.1 * (2 * pi),  # Control qubit frequency (GHz)\n",
    "    2: 4.9 * (2 * pi)  # Target qubit frequency (GHz)\n",
    "}\n",
    "\n",
    "anharmDict = {\n",
    "    0: 0.0 * (2 * pi),  # Coupler anharmonicity (GHz)\n",
    "    1: -0.33 * (2 * pi),  # Control qubit anharmonicity (GHz)\n",
    "    2: -0.33 * (2 * pi)  # Target qubit anharmonicity (GHz)\n",
    "}\n",
    "\n",
    "couplingMap = {\n",
    "    (0, 1): 0.098 * (2 * pi),  # Coupling strength of coupler and control qubit (GHz)\n",
    "    (0, 2): 0.083 * (2 * pi),  # Coupling strength of coupler and target qubit (GHz)\n",
    "    (1, 2): 0.0025 * (2 * pi)  # Coupling strength of control qubit and target qubit (GHz)\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "380cd999",
   "metadata": {},
   "source": [
    "Next we use the above parameters to instantiate an object of the `PulseModel` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b18b0cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "exampleModel = PulseModel(subSysNum=subSysNum, sysLevel=subSysLevel, qubitFreq=freqDict, qubitAnharm=anharmDict,\n",
    "                   couplingMap=couplingMap, frameMode='lab', dt=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "572ae05f",
   "metadata": {},
   "source": [
    "After constructing the Hamiltonian, we will demonstrate how to use the analysis tools for the $ZZ$ coupling characteristics and implement cross resonance gates in the two-qubit with coupler architecture.\n",
    "\n",
    "**Note: To use the analysis tools for two-qubit with coupler architecture, we need to set the number of energy levels of the coupler as 3 and the number of energy levels of the qubit as 4. The index of the coupler should be 0, and the indexes of the qubits should be 1, 2.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3961879",
   "metadata": {},
   "source": [
    "## Static $ZZ$ coupling analysis\n",
    "\n",
    "To study the properties of the two-qubit with coupler architecture, we need to convert the Hamiltonian of the system to an effective two-qubit direct coupling model. The Hamiltonian is as follows \\[2\\]，\n",
    "\n",
    "$$ \n",
    "\\hat{H}_{\\rm eff} = \\sum_{i = 1, 2}\\left(\\tilde{\\omega}_{i}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i} + \\frac{\\delta_{i}}{2}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i}^{\\dagger}\\hat{a}_{i}\\hat{a}_{i}\\right) + J(\\hat{a}_{1} + \\hat{a}_{1}^{\\dagger})(\\hat{a}_{2} + \\hat{a}_{2}^{\\dagger}),\n",
    "$$\n",
    "\n",
    "where $\\tilde{\\omega}_{i}$ is the dressed frequency of the qubit, $J$ represents the effective coupling strength between the qubits. The effective coupling is a crucial parameter of a two-qubit structure with a coupler. We can change the effective coupling by tuning the frequency of the coupler to \"turn on\" or \"turn off\" the coupling between the two qubits. \n",
    "\n",
    "In Quanlse, we can directly obtain the effective coupling through the `effectiveCoupling()` function and input the instantiated `PulseModel` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "109124d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtain effective coupling strength (GHz)\n",
    "print(f\"Effective coupling strength: {(effectiveCoupling(exampleModel) / 2 / pi)} (GHz)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aff3325",
   "metadata": {},
   "source": [
    "The Hamiltonian of the effective coupling model in the two-qubit computational subspace can be decomposed into a sum of Pauli operators (only the ground state and the first excited state of the qubits are considered) \\[4\\]\n",
    "\n",
    "$$ \n",
    "\\hat{H}_{\\rm sub} = \\alpha_{ZI}\\frac{ZI}{2} + \\alpha_{IZ}\\frac{IZ}{2} + \\alpha_{ZZ}\\frac{ZZ}{2}, \n",
    "$$\n",
    "\n",
    "where $IZ, ZI, ZZ$ are the Pauli operators in the two-qubit computational subspace. In our notation, the first Pauli operator acts on qubit 1 and the second Pauli operator acts on qubit 2. $\\alpha_{ZI}, \\alpha_{IZ}, \\alpha_{ZZ}$ are the Pauli coefficients.\n",
    "\n",
    "We can use the `pauliCoefficient` function and input a `PulseModel` object to obtain the Pauli coefficients in the computational subspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f6162f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Pauli coefficient: (GHz)\")\n",
    "print(f\"  ZI: {pauliCoefficient(exampleModel)['ZI']}\")\n",
    "print(f\"  IZ: {pauliCoefficient(exampleModel)['IZ']}\")\n",
    "print(f\"  ZZ: {pauliCoefficient(exampleModel)['ZZ']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39d57565",
   "metadata": {},
   "source": [
    "Here, the $ZZ$ term accounts for the crosstalk noise between qubits. In the two-qubit with coupler architecture, we can change the effective coupling strength $J$ between qubits by adjusting the frequency of the coupler to eliminate $ZZ$ interaction. We demonstrate how to choose the appropriate coupler frequency to eliminate the crosstalk noise between qubits. By tuning the coupler frequencies, we can obtain the effective coupling strength $J$ and $ZZ$ interaction strength as a function of coupler frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a82f6d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "freqList = linspace(6.3, 8.8, 200) * (2 * pi)  # The range of different coupler frequencies, in 2 pi GHz\n",
    "\n",
    "freqDict = deepcopy(freqDict)\n",
    "\n",
    "effectiveCouplingList = []\n",
    "zzList = []\n",
    "\n",
    "# Calculate effective coupling and ZZ interaction for different coupler frequencies\n",
    "for freq in freqList:\n",
    "    freqDict[0] = freq\n",
    "    exampleModel.qubitFreq = freqDict\n",
    "    effectiveCouplingList.append(effectiveCoupling(exampleModel))\n",
    "    zzList.append(pauliCoefficient(exampleModel)['ZZ'])\n",
    "    \n",
    "plt.figure(figsize=[14, 6])\n",
    "plt.subplot(121)\n",
    "plt.plot(freqList / (2 * pi), abs(array(effectiveCouplingList) * 1e3))\n",
    "plt.xlabel(r'$\\omega_c$ (GHz)', fontsize=15)\n",
    "plt.ylabel(r'$|\\ J\\ |$ (MHz)', fontsize=15)\n",
    "\n",
    "plt.title('The absolute values of effective coupling strength', fontsize=15)\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(freqList / (2 * pi), abs(array(zzList)) * 1e6, 'r')\n",
    "plt.xlabel(r'$\\omega_c$ (GHz)', fontsize=15)\n",
    "plt.ylabel(r'$|ZZ|$ (kHz)', fontsize=15)\n",
    "\n",
    "plt.title('The absolute values of ZZ interaction strength', fontsize=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24ceaab1",
   "metadata": {},
   "source": [
    "We can see that the effective coupling strength $J$ and the strength of $ZZ$ crosstalk are nearly zero when the coupler frequency is around 8.25 GHz where the crosstalk between these two qubits is therefore eliminated."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1766a4c",
   "metadata": {},
   "source": [
    "## Cross resonance effect analysis\n",
    "\n",
    "In the two-qubit architecture with a coupler, [iSWAP gate](https://quanlse.baidu.com/#/doc/tutorial-iswap) and [Control-Z gate](https://quanlse.baidu.com/#/doc/tutorial-cz) can be achieved by tuning the coupler frequency or the qubit frequency. The [Cross resonance gate](https://quanlse.baidu.com/#/doc/tutorial-cr) (CR gate) is achieved through a cross resonance effect (CR effect) which is implemented by applying a driving pulse to the control qubit. In this session, we will introduce how to use the analysis tools for the tunable coupling two-qubit architecture in Quanlse. The Hamiltonian of the CR effect in the tunable coupling two-qubit architecture is given by\n",
    "\n",
    "$$ \n",
    "\\hat{H}_{\\rm CR} = \\hat{H}_{\\rm sys} + \\hat{H}_{\\rm drive}, \\\\\n",
    "\\hat{H}_{\\rm drive} = \\Omega \\cos(\\omega_d t)(\\hat{a}_{1} + \\hat{a}_{1}^{\\dagger}), \n",
    "$$\n",
    "\n",
    "where $\\hat{H}_{\\rm drive}$ is the driving term，$\\Omega$ is the driving amplitude and $\\omega_d$ is the driving frequency. Here we set qubit 1 to be the control qubit.\n",
    "\n",
    "The system Hamiltonian can be reduced to the effective CR Hamiltonian by rotating wave approximation (RWA) in the rotating frame and projection onto the computational subspace, expressed as the linear combination of Pauli operators:\n",
    "\n",
    "$$ \n",
    "\\hat{H}_{\\rm CR,sub} = \\alpha_{ZI}\\frac{ZI}{2} + \\alpha_{IZ}\\frac{IZ}{2} + \\alpha_{ZZ}\\frac{ZZ}{2} + \\alpha_{IX}\\frac{IX}{2} + \\alpha_{IY}\\frac{IY}{2} + \\alpha_{ZX}\\frac{ZX}{2} + \\alpha_{ZY}\\frac{ZY}{2}.\n",
    "$$\n",
    "\n",
    "$\\alpha_{ZI}, \\alpha_{IZ}, \\alpha_{ZZ}, \\alpha_{IX}, \\alpha_{IY}, \\alpha_{ZX}, \\alpha_{ZY}$ are the corresponding Pauli coefficients. \n",
    "For CR gates, the $ZX$ term is required for the gate implementation, while $ZZ, IX, ZY, IY$ are the noise terms. By adjusting the device parameters or the amplitude of the driving pulse, the intensities of different Pauli operators can be changed, thus eliminating nosie. Here, we will demonstrate how the intensities of the different Pauli operators in the CR effect change depends on the different driving amplitudes `drivingAmp` \\[4\\].\n",
    "\n",
    "We can use the `pauliCoefficient()` function and input the instantiated `PulseModel` object and the driving amplitude `drivingAmp` to obtain the Pauli coefficients in the computational subspace. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5c307c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "drivingAmpRange =linspace(0, 0.10, 50) * 2 * pi\n",
    "coeffs = []\n",
    "\n",
    "for drivingAmp in drivingAmpRange:\n",
    "    coeffs.append(pauliCoefficient(exampleModel, drivingAmp))\n",
    "    \n",
    "ZI = array([coeff['ZI'] for coeff in coeffs])\n",
    "IZ = array([coeff['IZ'] for coeff in coeffs])\n",
    "ZZ = array([coeff['ZZ'] for coeff in coeffs])\n",
    "ZX = array([coeff['ZX'] for coeff in coeffs])\n",
    "ZY = array([coeff['ZY'] for coeff in coeffs])\n",
    "IX = array([coeff['IX'] for coeff in coeffs])\n",
    "IY = array([coeff['IY'] for coeff in coeffs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b60f4ab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define unit\n",
    "unit = 1e3 / (2 * pi)\n",
    "\n",
    "plt.figure(figsize=[14, 6])\n",
    "plt.subplot(121)\n",
    "[zx, ix] = plt.plot(drivingAmpRange * unit, ZX * 1e3, drivingAmpRange * unit, IX * 1e3)\n",
    "plt.legend([zx, ix], ['ZX', 'IX'], fontsize=12)\n",
    "plt.xlabel('Driving amplitude (MHz)', fontsize=15)\n",
    "plt.ylabel('Interaction strength (MHz)', fontsize=15)\n",
    "plt.title('Interaction strength vs Driving amplitude', fontsize=15)\n",
    "\n",
    "plt.subplot(122)\n",
    "[zz, zy, iz, iy] = plt.plot(drivingAmpRange * unit, ZZ * 1e6, drivingAmpRange * unit, ZY * 1e6, drivingAmpRange * unit, \n",
    "                            IZ * 1e6, drivingAmpRange * unit, IY * 1e6)\n",
    "plt.legend([zz, zy, iz, iy], ['ZZ', 'ZY', 'IZ', 'IY'], fontsize=12)\n",
    "plt.xlabel('Driving amplitude (MHz)', fontsize=15)\n",
    "plt.ylabel('Interaction strength (kHz)', fontsize=15)\n",
    "plt.title('Interaction strength vs Driving amplitude', fontsize=15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2947696",
   "metadata": {},
   "source": [
    "From the above figure, it can be seen that the intensities of the different Pauli operators changes as the amplitude of the driving pulse changes, and by selecting the pulse amplitude corresponding to high $ZX$ intensity and low noise intensities, a high fidelity CR gate can be achieved."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68b397b",
   "metadata": {},
   "source": [
    "## Preparation of the Bell state\n",
    "\n",
    "Below we will demonstrate how to use the two-qubit with coupler architecture to prepare a Bell state. A Bell state denotes a two-qubit maximally entangled state\\[3\\]. An example is the state $ 1 / \\sqrt{2} ( | 00 \\rangle + | 11 \\rangle )$. It can be prepared by the circuit below, in which we use $ X_{\\pi / 2} $, namely the $ \\pi / 2 $ rotation gate along the $ x $ axis, and a two-qubit CNOT gate.\n",
    "\n",
    "![Bell-state-CNOT](figures/Bell-state-CNOT.png)\n",
    "\n",
    "In this section, we use a predefined `PulseModel` instance with the default configuration. For the sake of simplicity, the energy levels of the coupler and the qubits are both set to 2. The position parameter of the coupler is 0, and the position parameter of the qubits are 1, 2 respectively. We first instantiate the `PulseModel` object by calling `pulseSimQCQ`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9770088",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = pulseSimQCQ(dt = 0.01, frameMode='lab')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b661bcf",
   "metadata": {},
   "source": [
    "For this predefined `PulseModel` instance with the default configuration, Quanlse provides calibrated single-qubit and two-qubit gate operations. We can use these gate operations to define the quantum circuit needed to prepare the Bell state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "514b1097",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RX(pi / 2) gate\n",
    "RX(pi / 2)(model.Q[1])\n",
    "\n",
    "# CNOT: 1 -> 2\n",
    "CNOT(model.Q[1], model.Q[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aecac6c0",
   "metadata": {},
   "source": [
    "The pulse sequence of the quantum circuit defined above is generated by calling the method `model.schedule` . We plot the pulse job by `plot()`. In the figure `uWave1` and `uWave2` are the pulse signals applied to the control qubit and the target qubit, respectively. The coupler channel has no pulse signal, therefore is omitted here. Here, we use the Echo-CR scheme to implement a CR gate \\[6\\], and construct a CNOT gate by the single-qubit gate and the CR gate (more details see [Cross resonance gate](https://quanlse.baidu.com/#/doc/tutorial-cr))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b33ff0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "scheJob = model.schedule()\n",
    "scheJob.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "605cf3f9",
   "metadata": {},
   "source": [
    "Define the initial state $| \\psi \\rangle = | 000 \\rangle$, in which the three numbers label the state of the coupler, the state of the control qubit and the state of the target qubit respectively. Then, we run the simulation and plot the probability distribution of different outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c74db111",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the simulation\n",
    "psi0 = basis(8, 0)\n",
    "res = model.simulate(state0=psi0, job=scheJob)\n",
    "\n",
    "psi1 = res[0]['state']\n",
    "\n",
    "# Plot the result\n",
    "popList = [abs(item ** 2) for item in res[0]['state'].T[0]]\n",
    "basisList = computationalBasisList(3, 2)\n",
    "plotBarGraph(basisList, popList, \"Result\", \"Outcome\", \"Population\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55aef8a5",
   "metadata": {},
   "source": [
    "As can be seen from the above figure, the measurement outcomes are mainly the $|000\\rangle$ state and the $|011\\rangle$ state. Therefore, we obtained an approximated Bell state with a fidelity of 80%."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432c3cf8",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "We have introduced how to use Quanlse to analyze the $ZZ$ coupling and the cross resonance gate characteristics in the two-qubit with coupler architecture, and demonstrated the preparation of the Bell state based on the this architecture. Users can click this link [tutorial-tunable-coupling-architectrue-two-qubit-simulator.ipynb](https://github.com/baidu/Quanlse/blob/main/Tutorial/EN/tutorial-two-qubit-simulator-with-coupler-architecture.ipynb) to jump to the corresponding GitHub page of this Jupyter Notebook document to get the relevant code. We recommend that users use different parameters from this tutorial to analyze the two-qubit architecture with couplers, simulate the realization of two-qubit gates, and develop analysis tools with a broader range of applications."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0556b09f",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "\\[1\\] [Yan Fei, et al. \"Tunable coupling scheme for implementing high-fidelity two-qubit gates.\" *Physical Review Applied* 10.5 (2018): 054062.](https://journals.aps.org/prapplied/abstract/10.1103/PhysRevApplied.10.054062)\n",
    "\n",
    "\\[2\\] [Arute, Frank, et al. \"Quantum supremacy using a programmable superconducting processor.\" *Nature* 574.7779 (2019): 505-510.](https://www.nature.com/articles/s41586-019-1666-5)\n",
    "\n",
    "\\[3\\] [Wu, Yulin, et al. \"Strong quantum computational advantage using a superconducting quantum processor.\" *arXiv preprint arXiv:2106.14734* (2021).](https://arxiv.org/abs/2106.14734)\n",
    "\n",
    "\\[4\\] [Magesan, Easwar, and Jay M. Gambetta. \"Effective Hamiltonian models of the cross-resonance gate.\" *Physical Review A* 101.5 (2020): 052308.](https://link.aps.org/doi/10.1103/PhysRevA.101.052308)\n",
    "\n",
    "\\[5\\] [\"Bell state\" *Wikipedia*.](https://en.wikipedia.org/wiki/Bell_state)\n",
    "\n",
    "\\[6\\] [Córcoles, Antonio D., et al. \"Process verification of two-qubit quantum gates by randomized benchmarking.\" *Physical Review A* 87.3 (2013): 030301.](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.87.030301)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
